package ar.edu.utn.frgp.EjemploHibernate.service.impl;

import java.util.List;

import ar.edu.utn.frgp.EjemploHibernate.dao.IClienteDao;
import ar.edu.utn.frgp.EjemploHibernate.dao.IProyectosDao;
import ar.edu.utn.frgp.EjemploHibernate.dao.IRealizadoDao;
import ar.edu.utn.frgp.EjemploHibernate.dao.ITesterDao;
import ar.edu.utn.frgp.EjemploHibernate.model.Cliente;
import ar.edu.utn.frgp.EjemploHibernate.model.Proyectos;
import ar.edu.utn.frgp.EjemploHibernate.model.Realizado;
import ar.edu.utn.frgp.EjemploHibernate.model.Tester;
import ar.edu.utn.frgp.EjemploHibernate.service.BusinessException;
import ar.edu.utn.frgp.EjemploHibernate.service.IRecursoService;

public class RecursoServiceImpl implements IRecursoService {

	private IClienteDao clienteDao;
	private ITesterDao testerDao;
	private IProyectosDao proyectosDao;
	private IRealizadoDao realizadoDao;

	// Esta anotacion solo debemos usarla si usamos el transactionManager sin
	// AOP (AspectJ)
	// @Transactional

	// /// CLIENTE
	public void crearCliente(Cliente cliente) throws BusinessException {

		if (clienteDao.getById(cliente) == null) // si no existe lo creo
		{
			cliente.setEstado(1);
			clienteDao.create(cliente);
		} else
			throw new BusinessException("El cliente ya existe en la base de datos"); // lanzo
																						// la
																						// excepcion
	}

	public Cliente getCliente(String dni) {
		return null;
	}

	public IClienteDao getClienteDao() {
		return clienteDao;
	}

	public List<Cliente> getClientes() {
		return clienteDao.getAll();
	}

	public List<Cliente> getClientesActivos() {
		return clienteDao.getAllActivos();
	}

	public void setClienteDao(IClienteDao clienteDao) {
		this.clienteDao = clienteDao;
	}

	public void modificarCliente(Cliente cliente) throws BusinessException {

		try {
			Cliente clienteOriginal = clienteDao.getById(cliente);

			if (clienteOriginal.getEstado() == 0) {
				throw new BusinessException("No se puede modificar un cliente que ha sido eliminado.");
			}
			cliente.setEstado(1);
			clienteDao.update(cliente);

		} catch (BusinessException busEx) {
			throw busEx;
		} catch (Exception e) {
			throw new BusinessException("Se produjo un error al intentar modificar el cliente.");
		}
	}

	public void bajaCliente(Cliente cliente) throws BusinessException {
		Cliente clientebaja = new Cliente();
		clientebaja = clienteDao.getById(cliente);
		clientebaja.setEstado(0);
		clienteDao.update(clientebaja);
	}

	// /// TESTER

	public void crearTester(Tester tester) throws BusinessException {

		if (testerDao.getById(tester) == null) // si no existe lo creo
		{
			tester.setEstado(1);
			testerDao.create(tester);
		} else
			throw new BusinessException("El tester ya existe en la base de datos"); // lanzo
																					// la
																					// excepcion
	}

	public Tester getTester(String idtester) {
		return null;
	}

	public ITesterDao getTesterDao() {
		return testerDao;
	}

	public List<Tester> getTester() {
		return testerDao.getAll();
	}

	public List<Tester> getTesterActivos() {
		return testerDao.getAllActivos();
	}

	public void setTesterDao(ITesterDao testerDao) {
		this.testerDao = testerDao;
	}

	public void modificarTester(Tester tester) throws BusinessException {

		try {
			Tester testerOriginal = testerDao.getById(tester);

			if (testerOriginal.getEstado() == 0) {
				throw new BusinessException("No se puede modificar un tester que ha sido eliminado.");
			}
			tester.setEstado(1);
			testerDao.update(tester);

		} catch (BusinessException busEx) {
			throw busEx;
		} catch (Exception e) {
			throw new BusinessException("Se produjo un error al intentar modificar el tester.");
		}
	}

	public void bajaTester(Tester tester) throws BusinessException {
		Tester testerbaja = new Tester();
		testerbaja = testerDao.getById(tester);
		testerbaja.setEstado(0);
		testerDao.update(testerbaja);
	}

	// /// Proyectos
	public void crearProyectos(Proyectos proyectos) throws BusinessException {

		if (proyectosDao.getById(proyectos) == null) // si no existe lo creo
		{
			proyectos.setEstado(1);
			proyectosDao.create(proyectos);
		} else
			throw new BusinessException("El proyecto ya existe en la base de datos"); // lanzo
																						// la
																						// excepcion
	}

	public Proyectos getProyectos(String id_proyecto) {
		return null;
	}

	public IProyectosDao getProyectosDao() {
		return proyectosDao;
	}

	public List<Proyectos> getProyectos() {
		return proyectosDao.getAll();
	}

	public List<Proyectos> getProyectosActivos() {
		return proyectosDao.getAllActivos();
	}

	public void setProyectosDao(IProyectosDao proyectosDao) {
		this.proyectosDao = proyectosDao;
	}

	public void modificarProyectos(Proyectos proyectos) throws BusinessException {

		try {
			Proyectos proyectosOriginal = proyectosDao.getById(proyectos);

			if (proyectosOriginal.getEstado() == 0) {
				throw new BusinessException("No se puede modificar un proyecto que ha sido eliminado.");
			}
			proyectos.setEstado(1);
			proyectosDao.update(proyectos);

		} catch (BusinessException busEx) {
			throw busEx;
		} catch (Exception e) {
			throw new BusinessException("Se produjo un error al intentar modificar el proyecto.");
		}
	}

	public void bajaProyectos(Proyectos proyectos) throws BusinessException {
		Proyectos proyectosbaja = new Proyectos();
		proyectosbaja = proyectosDao.getById(proyectos);
		proyectosbaja.setEstado(0);
		proyectosDao.update(proyectosbaja);
	}

	// /// Realizado
	public void crearRealizado(Realizado realizado) throws BusinessException {

		if (realizadoDao.getById(realizado) == null) // si no existe lo creo
		{
			realizado.setEstado(1);
			realizadoDao.create(realizado);
		} else
			throw new BusinessException("El cliente ya existe en la base de datos"); // lanzo
																						// la
																						// excepcion
	}

	public Realizado getRealizado(String id_carga) {
		return null;
	}

	public IRealizadoDao getRealizadoDao() {
		return realizadoDao;
	}

	public List<Realizado> getRealizado() {
		return realizadoDao.getAll();
	}

	public List<Realizado> getRealizadoActivos() {
		return realizadoDao.getAllActivos();
	}

	public void setRealizadoDao(IRealizadoDao realizadoDao) {
		this.realizadoDao = realizadoDao;
	}

	public void modificarRealizado(Realizado realizado) throws BusinessException {

		try {
			Realizado realizadoOriginal = realizadoDao.getById(realizado);

			if (realizadoOriginal.getEstado() == 0) {
				throw new BusinessException("No se puede modificar un realizado que ha sido eliminado.");
			}
			realizado.setEstado(1);
			realizadoDao.update(realizado);

		} catch (BusinessException busEx) {
			throw busEx;
		} catch (Exception e) {
			throw new BusinessException("Se produjo un error al intentar modificar el realizado.");
		}
	}

	public void bajaRealizado(Realizado realizado) throws BusinessException {
		Realizado realizadobaja = new Realizado();
		realizadobaja = realizadoDao.getById(realizado);
		realizadobaja.setEstado(0);
		realizadoDao.update(realizadobaja);
	}

}
